perm filename HELP.RAN[PNT,HE]4 blob
sn#646140 filedate 1982-03-06 generic text, type T, neo UTF8
displays this informationwhat to do about apparent bugs If there appear to be bugs, or something does
not work the way you think it should, a good source is this helper or
the AL USERS' MANUAL, which you should be familiar with if
you are running this program by yourself.
If either of these sources do not convince you it is not a bug,
you can log down the error and what you were doing at the time, and
your cusswords by getting out of the helper and typing these
things between open and close brace pairs{}. e.g. {arm refused to move}
This will be treated as a comment, but will be recorded in a logging
file.
When you are done with POINTY, send or mail MSM a message
saying that there were bugs, and complaints were logged in the
logging file.
Type one of the keywords on the left column. If you
don't understand any of this, type HELP. The #### you see at the
bottom of the screen is the prompt from the HELP module.help on the use of this helper This helper is organized as a directed
graph with loops, and to each node there corresponds a message.
Terminal nodes have no keyword associated with them, whereas
inside nodes do. (This means that you cannot go beyond the terminal
node.)
If the message is too long to fit on the screen,
<formfeed> and <vert tab> may be used to scroll the text up and down
the screen the way E does. If the message can fit in one screenful
<formfeed> and <vert tab> will have no effect.
To get more information in the help mode, type legitimate
keywords to the prompt #### at the bottom of the screen.
Legitimate keywords are as follows:
a) The list of keywords on the left hand column of the
screen (if there are are any - there will be some unless you are
looking at the terminal mode).
b) The list of keywords on the left hand column of the
screen the previous time.
c) The list of keywords on the keyword stack at the
bottom of the screen.
Keywords are stacked as they are invoked, so that it is
possible to tell the route by which you got to the current node.
If you type a valid keyword, that keyword will appear
as the last element of the keyword stack. Since keywords
are not repeated on the keyword stack, this means that sometimes
the keyword stack may be trimmed back.
If an invalid keyword is typed, it is as if you typed ?
but the keyword stack will not be cut back.
Note that you are now in a different mode. Normal POINTY
or AL commands will not work until you get out of the helper mode
by using the DONE command. When you reenter the HELP module at a
later time, you will be in the state you left it.
You can also invoke the HELP facility by giving an argument
immediately after HELP and a space, and the facility will search
through the keywords until it comes up with the particular keyword
and it will display according to that keyword. This is provided
to produce immediate help on certain topics if the user wants to
bypass the normal sequence of going through the beginning of
chain of keywords.
********* IMPORTANT NOTE ********* This HELP module is not designed
to teach you to program in AL or POINTY. Rather it is meant to
be a description of the system, and the user is presumed to
know a little bit about AL or POINTY by reading the AL USERS' MANUAL
or talking to someone in the Stanford Hand-Eye project.ideas for other help topics If there is a help topic that you think should
be here that isnt, please send a message to MSM about it, with
suggestions for the text of the message and at what level it should be
invoked. Any suggestions will be seriously considered.goes up a level on the keyword stackgives a list of toplevel instructionsgives a list of reserved wordsThese are reserved words:
ABORT ACOS ADC AFFIX ALL AND ARRAY ASIN ATAN2
AXIS BAIL BEGIN BY CALIB CASE CENTER
CLOSE COBEGIN COEND COMMENT CONSTRUCT COS
DAC DDT DEFINE DELETE DISPLAY DO DRIVE DUMP_VARIABLES
ECHOOFF ECHOON EDIT EEDIT END EQV EVAL EVENT
EXIT EXP {FCONSTRUCT} FOR FRAME FUNCTION
GATHER GRAPH HELP IF INT INTO INV
LOAD_VARIABLES
MAX MIN MOD MOVE MOVEX MOVEY MOVEZ
NODISPLAY NOUPDATE ON OPEN OR ORIENT
PARK PCART PFREE PJOINT POS PRINT PROCEDURE PROMPT
QBAIL QREAD
READ READWRIST REDEFINE REDISPLAY REFERENCE
REL RENAME RESETSTATUS RESUME_MESSAGE RETURN RETRY ROT
SAVECOREIMAGE SCALAR SETBASE SETSTATUS SETSTIFF SHOW
SIGNAL SIN SQRT STOP STOPMESSAGE SUBTREE
TAN TO TRANS UNFIX UNIT UPDATE
VALUE VECTOR VT05_OFF VT05_ON
WAIT WHILE WRIST WRITE WRT
XCOORD XOR YCOORD XCOORDgives one line descriptions of the reserved wordsABORT stops the current action and throws you into DDT
ACOS arc cosine
ADC analog to digital convertor input
AFFIX affix statement
ALL reserved word used with WRITE, DELETE, etc
ARRAY used for array declarations
ASIN arc sine
ATAN2 arctangent taking two arguments
BAIL calls the SAIL debugger: not available in all versions
BEGIN denotes beginning of a block
BY reserved word used in MOVE, OPEN, CLOSE, AFFIX
CASE control statement
CALIB to allow turning on high power to pumas
CLOSE close the hand
COBEGIN parallel control
COEND indicates end of COBEGIN block
COMMENT comment statment: non executabl statement
CONSTRUCT makes a trans out of three vectors
COS cosine function
DAC digital to analog convertor output
DDT throws you into DDT: you better know what you are doing
DEFINE macro definitions
DELETE deletes variables
DISPLAY displays appropriate data types
DO loop
DUMP_VARIABLES saves all the values of variables in a disk file
DRIVE moves individual joints
ECHOOFF suppresses printing of input file: normal mode for QREAD
ECHOON prints out input file: normal mode for READ
EDIT edits values of variable or macro
EEDIT swaps to E for editing
END ends a block
≡ EQV equivalence
EVAL direct evaluation
EVENT event declaration
EXIT exits from POINTY, can resume by typing CONT
EXP exponentiation
FCONSTRUCT constructs frame from 3 transes
FOR loop iteration
FRAME frame definition or declaration
FUNCTION no longer valid
GATHER to gather data
HELP gets the help moe
IF if control statement
INT integer part of a scalar expression
INTO used for COPY/MERGE
INV inverse trans
LOAD_VARIABLES reads in the variables from a dump file
LOG logarithm
MAX maximum of two expressions
MIN minimum of two scalar expressions
MOD modulus (remainder)
MOVE general motion statement
MOVEX motion in the X direction
MOVEY motion in the Y direction
MOVEZ motion in the Z direction
NODISPLAY shuts off the display
NOUPDATE does not update the display
ON condition monitor or used in motion statement
OPEN pertains to the hand opening
∨ OR boolean OR operator
ORIENT the rotation part of a frame or trans
PARK parks the arm
PCART allows cartesian motions in the puma arm
PFREE free individual joints in the puma arm
PJOINT allow single joint motions in the puma arm
POS vector part of a frame or trans
PRINT prints arguments on the VT05
PROCEDURE procedure declaration
PROMPT waits for user to type P at the VT05
QBAIL like BAIL, but takes input from QUERY.TXT on current PPN
QREAD like READ, but does not print on terminal what is being read
READ reads in the appropriate file
READWRIST reads the wrist
REDEFINE changes definition of a macro
REDISPLAY gets the normal table mode
REFERENCE type of argument used for parameter specification
REL relative positons
RENAME change the name of a variable
RESETSTATUS change the value of compiler parameters to 0
RESUME_MESSAGE the message to print out when resuming execution
RETURN gets out of a procedure
RETRY performs the motion again; valid only within error condition monitor
ROT the rotation operator or declaration
SAVECOREIMAGE saves the state of the 10 and 11
SCALAR used for declarations
SETBASE assumes there is zero force on the wrist
SETSTATUS changes the values of compiler parameters
SETSTIFF sets wrist stiffness matrix
SHOW displays values of a list of variables
SIGNAL signals the event
SIN the sine function
SQRT the square root function
STOPMESSAGE message received from interjob mail system is ended
TAN tangent function
TO used in AFFIX,MOVE,OPEN
TRANS used for declaration and to make trans data type
UNFIX the UNFIX statement
UNIT computes a unit vector
UPDATE updates the display
VALUE used for declaration of procedure parameters
VECTOR constructing data type or declaring vectors
VT05_OFF turns off updating of VT05
VT05_ON turns on updating of VT05 (default)
WAIT used with event
WHILE loop
WRIST reads the force wrist readings
WRITE writes AL declarations into a file
WRT operator
XCOORD refers to x-coordinate of a vector,trans or frame
XOR does exclusive or
YCOORD refers to y-coordinate of a vector,trans or frame
ZCOORD refers to z-coordinate of a vector,trans or framedescribes display commandsThe display commands relate to the display on the user
and there are several modes of display: the table display mode (the
display you get on starting up), the type display mode, the nodisplay
mode, and the variable display mode.
NODISPLAY takes no arguments, shuts off displays
REDISPLAY gets you back into the table display mode
DISPLAY <type> displays all the variables of type <type>,
where <type> may be SCALAR,VECTOR,ROT,TRANS,FRAME,
EVENT,MACRO,PROCEDURE
UPDATE forces immediate update of the display
NOUPDATE prevents updating of the display
SHOW <variable list> displays the variables in the <variable list>describes turning on and off the power to the arms The main power supply to all the arms is turned
on by pushing the red button on the underside of the short end of the
hand eye table closest to the blue and yellow arms.
The power supply to all the arms is turned off by pulling on the yellow
cord running around the edge of the hand-eye table.
Pressing the red button does not supply power to the PUMA arms
directly. If the PUMA arm is still under control of VAL, the PUMA
program should be run to initialize and calibrate the PUMA arm.
On the other hand, if the PUMA arm is directly controllable by AL,
(or by POINTY as the case may be), it must first be turned on
by typing CALIB(<GARM|RARM>). When the instruction on the VT05
asks if the PUMA is to be calibrated, press the black arm power
button on the PUMA controller until the red LED light comes on,
then type Y<RETURN> on the VT05 to let the PUMA be calibrated.describes use of PUMA arms with POINTYdescribes how to supply power to PUMAs under POINTYdescribes motion statements for PUMA The PUMA arms can be moved under POINTY
either directly through the runtime system or indirectly through
the VAL system. To be moved directly under POINTY requires
a syntax similar to the motion statement for the BLUE arm or
the YELLOW arm. To move the PUMA under VAL, type the command
VAL("<VAL instruction>");
or VAL("<VAL instruction>",WAIT);
or VAL("<VAL instruction>",NOWAIT);describes moving PUMA under joystick control The PUMA arm can also be moved under keyboard
control. The following are the current statements to give the
appropriate keyboard control. The statements must be followed by
RARM or GARM in parentheses. For example PFREE is invoked by
PFREE(GARM) or PFREE(RARM)
PFREE - to get joint free mode
PTABLE - to get cartesian motion mode in table coordinates
PJOINT - to get joint motion mode
PTOOL - to get cartesian motion in tool coordinates
PGRAV - to free up all the joints
The VT05 will wait for a response. The following pertains to
characters typed on the VT05.
For PFREE, typing the joint number will free the joint
so it can be moved manually. Typing any other character
will cause the brakes to come on again.
For PJOINT (when the arm is in joint control mode)
Typing appropriate number determines the joint to move
J causes it to move in positive direction
F causes it to move in negative direction
; causes it to speed up subsequently
A causes it to slow down subsequently
Q causes it to quit VT05 keyboard mode
any other character causes it to stop and wait for next
character
For PGRAV the arm should be statically balanced with the
brakes off. Typing any character will get you out of this mode.
For PTABLE of PTOOL (when the arm is in cartesian motion mode)
typing J causes motion in positive X direction
F causes motion in negative X direction
K causes motion in positive Y direction
D causes motion in negative Y direction
L causes motion in positive Z direction
S causes motion in negative Z direction
; causes subsequent motion to speed up
A causes subsequent motion to slow down
Q causes it to quit VT05 keyboard mode
O opens the hand
C closes the hand
any other character causes PUMA to stop and wait for next
charactergives information on the PDP-11 interfacedescription of the ELF The ELF is the name given to the interface
between the PDP-10 and PDP-11. Before POINTY can be run successfully,
the runtime system must be loaded and started across the ELF. The
ELF is a sharable device, which means that others may also use the
interface.
To get POINTY to work, type
R POINTY<cr>
If the ELF is being used by somebody else, you may
be able to execute the program. However, if someone else is using the
arms, you will not be able to run POINTY.
If the ARM is available, it will be assigned to your job
and the POINTY program started on the PDP-11.
Sometimes there may be errors that cause the
program to stop executing and enter DDT. When that happens,
try to find out what is wrong, and get it to continue executing,
normally by typing either <alt>P or RETRY<alt>G if you are
asked to do so or the interactive part on the PDP-10 will not work.
Don't type <alt>G or you will mess up whatever you did.ELF asleep message ELF is asleep, I will keep trying to wake it
until you type <ESC>I is the message you sometimes see printed at the
terminal. This gets printed out when the PDP-11 is in DDT, or it
is stuck in some inner loop. When the PDP-11 is in DDT, you will
have to get it to proceed by typing <ALT>P or RETRY<ALT>G
or FINISH<ALT>G. If the PDP-11 is stuck in some inner loop, there
is no easy way to get it unwedged, and the best thing to do is
to start all over again.
******* WARNING ****** NEVER TYPE <ALT>G to DDT while running this
program unless you know what you are doing.describes VT05The VT05 is a terminal directly connected to the PDP-11.
It prints out the status of the arm joints and limits.
VT05_ON prints out the joint angles continuously;
VT05_OFF shuts off the printing of joint angles on VT05
VT05_YELLOW displays the YELLOW ARM data
VT05_BLUE displays the BLUE ARM datashows available operators and functionsgives a list of logical operators≡ EQV equivalence ∨ OR logical OR⊗ XOR exclusive OR∧ AND logical AND¬ logical notlist of relational operators≤ < ≠ = > ≥ relational operatorsgives a list of arithmetic operatorslist of binary operatorslist of operations that give a scalar resultThe following operations return a scalar value.
These abbreviations are used: s = scalar,v = vector,r = rotation,
f = frame,t = trans.
s + s scalar addition
s - s scalar subtraction
s * s scalar multiplication
s / s scalar division
s ↑ s scalar raised to a scalar power
s MAX s maximum
s MIN s minimum
INT(s) integer part of s
s DIV s integer quotient after applying INT to each argument
s MOD s integer remainder after applying INT to each argument
v . v dot product of two vectors
|s| absolute value of a scalar
|v| magnitude of vector (vector norm)
|r| extracts angle of rotation
INSCALAR reads a scalar from the console
Scalar functions
SQRT(s) square root
SIN(s) sine (all trigonometric functions are in degrees)
COS(s) cosine
TAN(s) tangent
ASIN(s) arc-sine
ACOS(s) arc-cosine
ATAN2(s,s) arc-tangent of s/s
LOG(s) natural logarithm
EXP(s) e raised to the s power
s <rel> s returns true if relation is satisfied, else false
possible relations are: <,≤,=,≥,>,≠
s ∧ s logical and
s ∨ s logical or
s ⊗ s logical exclusive or
s ≡ s logical equivalence
¬ s logical not
QUERY reads a boolean from the consolelist of operations giving vector resultThe following operations return a scalar value.
These abbreviations are used: s = scalar,v = vector,r = rotation,
f = frame,t = trans.
VECTOR(s,s,s) construct vector given (x,y,z) components
s * v dilation of a vector
v / s contraction of a vector
v + v vector addition
v - v vector subtraction
v * v vector cross product
r * v rotation of a vector
t * v transformation of a vector
f * v transformation of a vector - shorthand for (station → f) * v
v WRT f vector in station coordinates pointing
the same way as v points in f's coordinate
system. v WRT f ≡ ORIENT(f)*v ≡ (f*v) - POS(f)
UNIT(v) vector of unit length with same direction as v
POS(f) vector position of frame or trans
AXIS(r) axis of rotationlist of operations giving rot resultThe following operations return a scalar value.
These abbreviations are used: s = scalar,v = vector,r = rotation,
f = frame,t = trans.
ROT(v,s) constructs rotation of s degrees about v
ORIENT(f) orientation of a frame or trans
r * r composition of two rotations (the one on the right
is applied first)list of operations giving frame resultsThe following operations return a frame value.
These abbreviations are used: s = scalar,v = vector,r = rotation,
f = frame,t = trans.
FRAME(r,v) constructs frame of orientation r at position v
CONSTRUCT(v,v,v) makes a frame: first vector gives the position,
second a point on the x-axis,
third is a point in the xy-plane
f + v translation of a frame
f - v translation of a frame
t * f transformation of a frame
f * f transformation of a frame - shorthand for (station → f) * flist of operations giving trans/frame resultThe following operations return a frame value.
These abbreviations are used: s = scalar,v = vector,r = rotation,
f = frame,t = trans.
TRANS(r,v) constructs trans which will cause a rotation of r
followed by a translation of v
f → f transformation which maps from the first frame
to the second
t * t composition of two transes (the one on the right is
applied first)
INV(t) take the inverse of textraction functionsimplicit data types+ addition- negation or difference. vector dot product* product/ divisionMAX maximum of two operandsMIN minimum of two operandsDIV integer division quotientMOD integer division remainderREL vector or trans relative to frameWRT vector or trans with respect to frame→ relative transform between two frames or transes↑ exponentiationORIENT rotation part of a frame or transUNIT conversion of a vector to unit vectorAXIS the axis of rotationINV inverse of a rot or transINT integer part of a scalarCONSTRUCT constructs a frame from 3 vectors↓ downward orientation$ station orientationα bpark orientation(???){EVAL evaluate immediate}|..| magnitude of scalar or vector, or angle of rotation( .. ) implicit data type declarationFRAME VECTOR TRANS ROT make the appropriate data typeXCOORD YCOORD ZCOORD the relevant component of the vector or transgives a list of available functionsLOG EXP relevant transcendental functionsSIN COS TAN ASIN ACOS ATAN2 relevant trig functionsSQRT square root functionvalid expressionstypes of expressionsbnf definition of expressionspriority of operatorsThe following are valid expressions:
S=scalar, V=vector,R=rot,T=trans,F=frame
RESULT OPERATION
S: S+S,S-S,S*S,S/S,S↑S,LOG(S),EXP(S),INT(S),S MAX S,S MIN S,
SIN(S),COS(S),TAN(S),ASIN(S),ACOS(S),ATAN2(S,S),
V.V
V: V+V,V-V,V*V,V*S,V/S,(S,S,S),VECTOR(S,S,S)
POS(F),POS(T)
R: ROT(V,S),ORIENT(F)
F: FRAME(R,V)
T: TRANS(R,V),(R,V)The following is the recursive definition of
expressions in bnf form:
<expression> ::= <befact>{{OR|XOR <befact>}}
<befact> ::= <bterm>{{AND <bterm>}}
<bterm> ::= <arith_exp>| <arith_exp> <rel> <arith_exp>
<arith_exp> ::= {+|-} <term> {{+|- <term>}}
<term> ::= <factor> {{*|/ <factor>}}
<factor> ::= <pfactor>{↑ <pfactor>}
<pfactor> ::= (<expression>) or |<expression>| or
<constant> or <id> or ¬ <pfactor> or funct or
funct(<expression>{{,<expression}}) The operators in AL generally follow
normal precedence rules, i.e., functions are evaluated first,
followed by exponentiations before multiplications or divisions,
which in turn are performed before additions and subtractions.
The order of operation can be changed by including parentheses
at appropriate points. In an expression where several operators
of the same precedence occur at the same level, the operations
are performed from left to right.
functions, (), | |, NOT
WRT → ↑
* / . MAX MIN DIV MOD
+ -
= ≠ < > ≤ ≥
∧
∨ ⊗
≡Gives the file management commandsSaves the terminal sessionSaves AL declarations, macros, procedures and arraysReads AL instructions from a disk fileFast loads variables saved from a fileDumps variables into a fileSaves the core image When you run POINTY, your terminal session
will be logged automatically into POINTY.PHT[PNT,HE].
If you wish to record your session
in another file as well, the command PHOTO <filename> will save
the terminal input into <filename>. Once PHOTO is called, it will
keep on recording until you make another call to PHOTO in which case
it will stop recording in the old file and start recording
into the new file name.
Recording can only be done into a file that is not being
referenced by some other user or job, and the file is written out
every 6 lines or so, so that if you accidentally kill your job
or the system crashes (knock on wood!) you will have a record of
your terminal session. The write command permits the state of the world
to be saved on a disk file. The syntax is as follows:
WRITE ALL|<var_list> {INTO <filename>}
The instruction will write the values of all the variables,
arrays, macros or the selected ones into the relevant file.
If the filename is not specified, it will be written into
the last file into which AL declarations were written. File input of AL commands can be done by means of
the READ <filename> command. The file will be read to completion unless
<ESCAPE> I is typed.
Note that defaults instructions will not work from file input,
and that statements must be separated by semicolons. Fast loads variables and procedure and macro
declarations from a file written out by the DUMP_VARIABLES command.
The syntax is as follows:
LOAD_VARIABLES <filename>
This procedure can only be invoked at toplevel. Dumps variable values and procedure and macro
declarations into a file in a form readable by the LOAD_VARIABLES
command. The syntax is as follows:
DUMP_VARIABLES <filename>
This command can only be invoked at top level. Saves the core image of the 10 and the 11.
This command saves the entire state of the program in a dump file
with extension .DMP. The syntax is as follows:
SAVECOREIMAGE <filename>
Note that you will not be allowed to save a file called POINTY.DMP.
(This is to protect against accidentally destroying the main
core image that runs the POINTY system.)
This will save a huge file (about 150K currently) and may easily
send you over your disk allocation, so be sparing in its use.
This command can only be invoked at top level.
After saving the core image, the program will continue
executing. If you want to get this state back at a later
time, you can do so by doing the monitor command
RU <filename>
If you would like the new program to print out a message
when it is executed subsequently, type RESUME_MESSAGE(<message>)
before you type SAVECOREIMAGE.ESCAPE I command Hitting the <ESC> key followed by an I will
interrupt whatever the PDP-10 is doing and throw you back to the
top level. Any type ahead will be destroyed. If a file is being
read, the rest of the file will be ignored.
This command is useful when there is some error in the
input file which causes the generation of a large number of error
messages, and you want to get command back to top level.
A second place this command is useful is when
there is some problem on the 11 and the system seems to be wedged.
In this case it is still possible to save the values of variables
that the PDP-10 knows about and start over.
Typing <esc> I may not work if it is done during
initialization, since the interrupt is not enabled at the
end of initialization.classes of statementsassignment statement The assignment statement is of the form
<variable> ← <expression>
or component(<variable>) ← <expression>
where component is XCOORD,YCOORD,ZCOORD,POS or ORIENT.
The data types on both sides of the assignment statement must
be the same for the assignment to work, except that trans
expressions may be assigned to frames.
In the first form, if <variable> has not been declared,
POINTY will declare it to be the same data type as the expression
on the right hand side. Predefined variables or constants
like BARM, YARM, BHAND, YHAND, XHAT,YHAT,ZHAT,NILVECT may
not have values assigned to them.
The planning assignment operator ←← of AL is recognized
and parsed, but is essentially a NOOP execpt that it serves
to declare the variable on the left hand side if it has not
already been declared.list of motion commandsopens the handsimilar to OPEN The OPEN/CLOSE command applied to
a hand causes the hand opening to go to the desired value.
The syntax is as follows:
OPEN <hand> TO|BY <scalar_exp>
CLOSE <hand> TO|BY <scalar_exp>
permitting the use of an absolute or relative value.
Note that OPEN bhand BY 1 is the same as CLOSE bhand BY -1.moves the arm The MOVE command specifies the motion of
the specified frame to the desired destination which may
be in absolute or relative terms. The syntax is as follows:
MOVE <frame> TO <dest>
<VIA clauses>
<condition monitors>
<clauses>
The VIA clause may come just after MOVE <frame> or after
TO <framefinal> or after the conidition monitors or clauses.
Note that condition monitors and clauses may be mixed.
There are two forms of the VIA clause. One is the form
where VIA is followed by a list of frame positions separated by
commas as follows:
VIA <frame1>,<frame2>,<frame3>,...<framen>
in which case you can have only one VIA clause.
In the other form, one intermediate location is given, but there are
qualifying clauses after the location as follows:
VIA <framei> WHERE DURATION = n
WITH VELOCITY =...
WITH SPEED_FACTOR = ...
THEN <statement>
where any of the qualifying clauses are optional.
Currently the condition monitors available are
the FORCE and TORQUE, ERROR, DURATION, EXPRESSION, and EVENT
condition monitors whose syntax are as follows:
ON FORCE(direction) <rel> <scalar_exp> {IN HAND|STATION}
DO <statement>
where <rel> is ≥ or < and direction is XHAT,YHAT, or ZHAT
ON ERROR=<compile time constant> DO <statement>.
ON DURATION > <scalar_exp> DO <statement>
ON <scalar_exp> DO <statement>
ON <event_id> DO <statement>
In <statement> it is possible to ask for RETRY and the current
motion command will be executed. The compile time constant must
set certain bits, and may be abbreviated by means of the following
macros which are already predefined:
DEFINE PANIC_BUTTON=⊂ 1024⊃; { = '2000 }
DEFINE EXCESSIVE_FORCE=⊂ 2048⊃; { ='4000 }
DEFINE TIME_OUT=⊂ 4096⊃; { ='10000 }
Clauses available are the DURATION, STIFFNESS, WRIST
ZEROED/NOT ZEROED, WOBBLE, SPEED_FACTOR, FORCE_FRAME
with the following syntax:
WITH DURATION=n where n is a compile time constant
WITH STIFFNESS = (<vect>,<vect>,<trans>)
WITH STIFFNESS = (<vect>,<vect>) AT <trans>
WITH WRIST ZEROED
WITH WRIST NOT ZEROED
WITH WOBBLE=n where n is a compile time constant
WITH SPEED_FACTOR = n where n is a compile time constant
WITH FORCE_FRAME = <trans> {IN HAND|STATION}driving single joints The DRIVE command is a motion command that permits
driving single joints. The syntax is as follows:
DRIVE <BJT|YJT>(n) <TO|BY> <amt>
where n is the joint number to be driver, <amt> is amount to be
driven in degrees or inches (depending on the joint), and
BJT refers to the blue arm and YJT refers to the yellow arm.
At the moment this instruction does not work with the PUMA arms.
You might want to try the PJOINT instruction, though.does a grasp The CENTER command does adaptive grasping.
The fingers move towards each other until one finger makes contact.
Keeping this finger in contact with the object, the hand closes
while the arm adjusts itself until the other finger makes contact
at which time the object has been grasped.
The syntax is as follows:
CENTER <arm>gathers force and torque data The GATHER command is used for collecting
force data during the next motion. You should put in as many
components as you are interested in. The syntax is as follows:
GATHER(c1,c2,...,cn)
where c1,c2,..cn are components and may be any of the terms
FX,FY,FZ,MX,MY,MZ,T1,T2,T3,T4,T5,T6,TBL. The first six represent
forces and torques in the principal directions. If TBL is specified,
the quantities are in table coordinates, otherwise in hand coordinates.
T1 thru T6 represent forces measured according to joints.
The gather command sets up the preparatory commands
for the next motion command, and after the next interaction
with the runtime system which involves a motion, the data
will be read back into POINTY and be available to be examined by
the GRAPH command.explains the GRAPH command The syntax of the graph command is simply
GRAPH. This command gets you into the module which helps to
plot and save force data on a disk file or display on a data disc.
This command is valid only after a GATHER and move. On exiting
the GRAPH module, the data is destroyed in order to reclaim the
space which the data occupies for some other purpose.declaration statement Declarations may be made explicitly as
in the case of AL, or implicitly by means of assignment statements.
Explicit declarations may be made by means of the following
syntactical construct:
<data_type> <variable list>
where <data_type> is one of SCALAR, VECTOR, ROT, TRANS, FRAME or
EVENT. <variable list> consists of a series of identifiers
separated by commas.
Arrays may be declared by including ARRAY after the data type,
e.g.
SCALAR ARRAY S[1:10,3:5]
The indices may be constants or scalar expressions. Scalar
arrays will be initialized to 0, vector arrays to nilvect,
rot arrays to nilrot, trans and frame arrays to niltrans.
Macros are declared by means of the DEFINE statement,
while procedures declarations are described in detail elsewhere.list of control statementsIF statement The IF statement has the following syntax:
IF <scalar exp> THEN <statement>
or IF <scalar exp> THEN <statement> ELSE <statement>
The IF statement cannot be used as an expression.FOR statement The FOR statement has the following syntax:
FOR <scalar> ← <scal exp> STEP <scal exp> UNTIL <scal exp>
DO <statement>DO statement The DO statement has the following syntax:
DO <statement> UNTIL <condition>
<statement> will be executed until <condition> becomes TRUEWHILE statement The WHILE statement has the following syntax:
WHILE <cond> DO <statement>
<cond> is a scalar expression, and is checked. If it is TRUE( non zero)
<statement> is executed and the <cond> checked and <statement>
executed and the sequence repeated until <cond> becomes FALSE(0).these are some of the other AL instructionsthis describes use of COMMENTS There are two forms of comment statements.
The first form is having the reserved word COMMENT followed
by anything and ended by a semicolon. The second
form is enclosing the comment between open and close brace pairs
e.g. {this is a comment} which may appear anywhere. Note that
the delimiters may be nested.these instructions facilitate interactionpermits the changing of the value of simple variables The EDIT command displays the values of
variables to be displayed in the line editor
and permits the user to change their values. The syntax of the
command is as follows:
EDIT <variable name>
where <variable name> is the name of the appropriate variable to be
changed. Currently only scalars, vectors, transes, rots or frames
variables which are not arrays may be edited. Macros may also be
edited by means of this command.
The EDIT command argument is sticky, i.e. if a variable
name is not given, it will assume that it is the last variable that
was edited.writes the macro in a file and swaps to E The EEDIT command takes a macro name
as argument and writes it out into a disk file. The core image
is then saved, and the program swaps to E where the user is
permitted to make changes to the macro body. This is particularly
useful when the macro body is a long one and many changes need
to be made to it. Minor changes may be made by means of the
EDIT command.
When you are satisfied with the macro, type <control>X RUN
and you will get back to POINTY. In the meantime please make sure
not to change the state of the program on the PDP-11.deletes some or all variables The DELETE command deletes all the user
defined variables or some of them. The syntax is as follows:
DELETE ALL
DELETE <variable list>
In the first form, all user declared variables are
deleted after asking for confirmation. In the second form
POINTY will complain if some of the variables in the list are
non existent. In the second form, frame arrays may not be
deleted. Also, individual elements of an array may not
be deleted.
A more liberal form of the instruction is executed
if DELETE is replaced by QDELETE. In the first form, confirmation
is not asked for, while in the second form, POINTY does not
complain if the name in the variable list is non existent.explains the SETSTATUS and RESETSTATUS commands The SETSTATUS and RESETSTATUS commands
are used to set compiler variables. The syntax is as follows:
SETSTATUS(<var>,<value>)
RESETSTATUS(<var>,<value>)
If <value> is left out, it defaults to 1 in the case of SETSTATUS
and 0 in the case of RESETSTATUS. <var> currently may be the
following:
NOELF - no output to the ELF
NOFOLD - no constant folding and evaluation of constant
scalars and reals
LINE - prints out the expanded version of the last
statement on the terminal
PPCODE - the pcode of the statement being parsed will
printed out at the terminal
PWCODE - the pcode of the statement being parsed will be
appended to the file PPCODE.FOO
ALPRIN - subsequent printout of variables in AL format
rather than POINTY format
PRTIME - prints the execution time for the current
instruction
DEBUG - gets you in debug mode which allows source level
break pointing, single stepping, etctalks about how to handle errorswhat to do if there is no arm action When the arm does not do what you expect
it to do, namely move, there will probably be a message printed
out at the VT05 console which may explain the error.
One of the commonest forms of errors is that the power
supply is off or one of the brake switches is off. For the
former, turn on the arm motor power by hitting the big red
button on the underside of one of the short sides of the table.
Sometimes the arm seems to move in weird fashions,
or will claim that it cannot move to the PARK position!
When this happens, it may be that the arm is not properly
initialised. In this case, just reload and start the system
again.
There are several forms of recovery.
RETRY<alt>G at the VT05 will try to repeat the motion.
<alt>P will go on with the next instruction.
FINISH<alt>G will cause the arm to go to its destination directly.
DO NOT ever type <alt>G during execution
of POINTY since this will throw the synchronization out, unless
you know what you are doing.explanation of error messages POINTY is based on the assumption
that it will be used interactively, and any errors encountered
during parsing a statement results in abandoning any further
processing and giving control back to the user.
This may cause grief if move commands
and errors occur in a disk file instead of in the terminal
input mode.
It also means that if you are trying to write
a long program interactively you better not make any typing
mistakes, or you will have to start over.
It is much easier to build up programs as macros
and to edit the macros if they do not behave as you think they
should. When you are happy with the macros, declare a procedure
with the appropriate macro as body.syntax of statementssyntax of file management commands WRITE ALL INTO <filename>
WRITE <variable list> INTO <filename>
WRITE ALL INTO <filename>
WRITE INTO <filename>
READ <filename>
QREAD <filename>
LOAD_VARIABLES <filename>
DUMP_VARIABLES <filename>
SAVECOREIMAGE <filename>syntax of display commands REDISPLAY
NODISPLAY
DISPLAY <SCALAR|VECTOR|ROT|TRANS|FRAME|EVENT>
SHOW <variable list>
VT05_ON
VT05_OFFsyntax of declaration commandsvariable declaration SCALAR s1,s2,s3,.....
VECTOR v1,v2,v3,...
ROT r1,r2,r3,...
TRANS t1,t2,t3,...
FRAME f1,f2,f3,...
EVENT e1,e2,e3,...
<SCALAR|VECTOR|ROT|TRANS|FRAME|EVENT> ARRAY a[l1:u1,l2:u2,...ln:un]procedure declaration Procedure declarations are as in SAIL,
and are fully recursive, may take parameters with defaults definedmacro declaration Macro declarations are as in SAIL,
and will take default values Syntax of other commands will be added
at a later date. If you would like to see them soon, please send
or mail a message to MSM.quits help modedetails of the high level debugger
DOCUMENTATION OF THE DEBUGGING FACILITIES IN POINTY
---------------------------------------------------
To set POINTY in debug mode the instruction
SETSTATUS(DEBUG) or
DEBUGON
are required. You can reset POINTY to the normal mode by typing
RESETSTATUS(DEBUG) or
DEBUGOFF
When in debug mode POINTY will stop at the beginning of any compound
statement you type in, while it doesn't stop if you type in a simple
statement.
When in debug mode POINTY reads general POINTY expressions typed by the
user, evaluates them in the context of the place in the program where
execution was suspended. The evaluation is performed just as if the user
had inserted an extra statement into the original program at the point
where execution was suspended. The user may ask to evaluate any POINTY
expression whose evaluation would be legal at the point at which the
execution of the program was suspended.
POINTY prompts the user for input by typing a ⊂:*:⊃. Input can be edited
using the standard line editor. The activation character is the semicolon
or the carriage return, whathever comes first.
The POINTY instructions typed are numbered starting from 1, so that
reference to an instruction can be done through its number, or
referred to as coordinate.
--------------------------------------------------------------------------
Here is the list of instructions available ONLY in debug mode:
--------------------------------------------------------------------------
BREAK(COORD)
BREAK("PROCEDURE_NAME", COORD)
Put a breakpoint at the specified point.
HALT
Send the control to the 10.
TEXT
TEXT(MIN#)
TEXT(MIN#,MAX#)
TEXT("PROCEDURE_NAME",MIN#)
TEXT("PROCEDURE_NAME",MIN#,MAX#)
Show the source text, from MIN# to MAX#. If MAX# < MIN# set MAX# to be
MIN#+MAX#. If MAX# is omitted set it to be MIN#. If both numbers are
omitted show the next instruction to be executed.
RESTART
Restart the program from the beginning. Can be called only when outside
from procedures.
TRAPS
Show the exixting breakpoints.
UNBREAK(COORD)
UNBREAK("PROCEDURE_NAME", COORD)
Remove a breakpoint from the specified point. Complain if no breakpoint
has been set.
!!GO, <CONTROL>G
Continue the execution, from the point where it was suspended.
!!STEP, <CONTROL>S
Execute next statement and stop after that.
!!GSTEP, <CONTROL>X
Execute next statement, considering compound statement or procedure calls
as a single statement, and stops after that.
--------------------------------------------------------------------------
KNOWN BUGS
--------------------------------------------------------------------------
TRAPS shows the breakpoints in the main program and in untyped procedures
(doesn't work yet for typed procedures)
COBEGIN/COEND cause severe problems. Don't try it!
building up a new POINTY systembuilding up system on the PDP-10 The system on the PDP-10 part can be built up
easily by means of the instruction "DO PCOMP[PNT,HE]". This DO
file deletes all the .REL files which are no longer valid, rewrites
INTOPS.SAI, and then proceeds to compile each of the files in the
POINTY system separately. It then loads the files and writes
out the PDP-10 part of the POINTY system as PONTY0.
When it is done, it sends and mails a message saying it has completed
its job.
***** CAUTION ****** This is given only as a matter of information.
Don't fool around with all these unless you are one of the people
working with the system.building up the POINTY runtime system There are four parts to the RUNTIME system and
generally two parts have to be reassembled. Reassamble POINTY.PAL
and PNTARM.PAL on [PNT,HE], and these files will automatically call
in AL.PAL and ARM.PAL respectively. Then to load up the 11 and
get a .SAV file do the following (the stuff after the semicolons are
comments for your information):
.A ARM ; assigns arm to your job
.R 11TTY ; runs 11TTY program
*Z500000 ; Zeroes 500000 words of core
*LPOINTY[PNT,HE] ; Loads AL runtime interpreter
*OPNTARM[PNT,HE] ; overlays arm code. if you need symbols
; as well use M instead of O
*OK1[11,SYS] ; overlays the kernal
*OPNTY[PNT,HE] ; overlays the AL program with data
; structures
*W160000 ; writes a 1 into 160000 to tell AL
*1 ; runtime interpreter that this is
; a POINTY system
*ATERM ; put the terminal into VT05 mode
*VT05
*SD <now on the VT05 type <alt>G and wait for scanning>
*ATOP ; set top address to be saved to 500000
*500000
*DPOINTY ; dumps the runtime system in the
; file POINTY.SAV
*X ; exits from 11TTY back to monitor
.
***** CAUTION ****** This is given only as a matter of information.
Don't fool around with all these unless you are one of the people
working with the system.describes building up the POINTY system The part on the 10 and the runtime must first be
built up, as described in SYS10 and SYS11. Then do the following:
.A ARM
.R 11TTY
*GPOINTY[PNT,HE]
*X
.RU PONTY0[PNT,HE]
When everything is working fine, type the instruction
SAVECOREIMAGE P0
The coreimage of both the parser on the 10 and the runtime system
on the the 11 will be saved in a file named P0. To resume the
execution at a later date, type RU P0. If you want to get at this
file by means of R POINTY, then rename this file POINTY.DMP[PNT,HE]
by means of the RENAME command as follows:
RENAME POINTY.DMP[PNT,HE]←P0.DMP
***** CAUTION ****** This is given only as a matter of information.
Don't fool around with all these unless you are one of the people
working with the system.describes the SAIL debugger and how to get at it To get the SAIL debugger in helping to debug
the system, type BAIL or BAIL(<list of BAIL instructions>).
This is applicable only if BAIL is loaded with the system,
(which will be done if POINTY.SAI and the files of interest are
compiled with a 27B, compilation).
An alternate way of getting at BAIL and not having to
type in repetitive instructions is to put those instructions into
a file called QUERY.TXT and that file will be read in if BAIL is
invoked with the QBAIL instruction.
While in BAIL, several variables are available for
general use. Thus !!i1,!!i2,!!i3,!!i4,!!i5,!!i6 are six integers
and !!r1,!!r2,!!r3,!!r4,!!r5,!!r6 are six record pointers.
This information is relevant only if you are working with
the POINTY or AL INTERPRETER system.